using System.Collections;
using System.Collections.Generic;
using UnityEngine;

/// <summary>
/// 土豆地雷 - 埋在地下的地雷，僵尸踩到时爆炸
/// </summary>
public class PotatoMine : Plant
{
    private PotatoMineSkillData m_SkillData;
    private PotatoMineData m_PotatoMineData;
    private bool m_IsArmed = false; // 是否已激活
    private bool m_HasExploded = false; // 是否已爆炸
    private Coroutine m_ArmCoroutine; // 激活协程
    private SpriteRenderer m_SpriteRenderer; // 用于控制显示/隐藏

    /// <summary>
    /// 是否已爆炸（供攻击策略检查）
    /// </summary>
    public bool HasExploded => m_HasExploded;

    public override void Initialize()
    {
        base.Initialize();
        
        // 获取技能数据
        if (AttackComponent != null && AttackComponent.AttackData is PotatoMineSkillData skillData)
        {
            m_SkillData = skillData;
        }
        else
        {
            Logger.LogWarning("PotatoMine", $"PotatoMine 的技能数据不是 PotatoMineSkillData 类型");
        }

        // 获取植物数据
        if (EntityData is PotatoMineData potatoMineData)
        {
            m_PotatoMineData = potatoMineData;
        }
        else
        {
            Logger.LogWarning("PotatoMine", $"PotatoMine 的 EntityData 不是 PotatoMineData 类型");
        }

        // 获取SpriteRenderer组件
        m_SpriteRenderer = GetComponent<SpriteRenderer>();
        if (m_SpriteRenderer == null)
        {
            m_SpriteRenderer = GetComponentInChildren<SpriteRenderer>();
        }

        // 设置触发器用于检测僵尸
        SetupTrigger();

        // 初始化时ready动画参数为false（不播放ready动画）
        if (Animator != null)
        {
            Animator.SetBool("ready", false);
        }

        // 启动激活协程
        if (m_SkillData != null && m_SkillData.ArmTime > 0)
        {
            m_ArmCoroutine = StartCoroutine(ArmRoutine());
        }
        else
        {
            // 如果没有激活时间，立即激活
            m_IsArmed = true;
            // 立即设置ready为true
            if (Animator != null)
            {
                Animator.SetBool("ready", true);
            }
        }
    }

    /// <summary>
    /// 设置触发器用于检测僵尸
    /// </summary>
    private void SetupTrigger()
    {
        var collider = GetComponent<Collider2D>();
        if (collider == null)
        {
            Logger.LogWarning("PotatoMine", $"{name} 没有 Collider2D 组件，无法检测僵尸");
            return;
        }

        // 确保是触发器
        collider.isTrigger = true;
        
        // 根据触发范围调整碰撞体大小
        float triggerRange = m_SkillData != null ? m_SkillData.TriggerRange : 0.5f;
        
        if (collider is BoxCollider2D boxCollider)
        {
            boxCollider.size = new Vector2(triggerRange * 2, triggerRange * 2);
        }
        else if (collider is CircleCollider2D circleCollider)
        {
            circleCollider.radius = triggerRange;
        }
    }

    /// <summary>
    /// 激活协程 - 等待激活时间后激活地雷
    /// </summary>
    private IEnumerator ArmRoutine()
    {
        if (m_SkillData == null)
        {
            yield break;
        }

        float armTime = m_SkillData.ArmTime;
        Logger.Log("PotatoMine", $"{name} 开始激活，需要等待 {armTime} 秒");

        // 等待1秒后，设置ready为true（播放ready动画）
        yield return new WaitForSeconds(1f);
        
        if (Animator != null)
        {
            Animator.SetBool("ready", true);
        }

        // 继续等待剩余的激活时间
        if (armTime > 1f)
        {
            yield return new WaitForSeconds(armTime - 1f);
        }

        // 激活地雷
        m_IsArmed = true;

        Logger.Log("PotatoMine", $"{name} 已激活，可以触发爆炸");
    }


    public override PlantType GetPlantType()
    {
        return PlantType.PotatoMine;
    }

    /// <summary>
    /// 检测僵尸进入触发范围
    /// </summary>
    private void OnTriggerEnter2D(Collider2D other)
    {
        // 如果已经爆炸，不再触发
        if (m_HasExploded)
        {
            return;
        }

        // 如果还未激活，不触发
        if (!m_IsArmed)
        {
            return;
        }

        // 检测是否是僵尸
        var zombie = other.GetComponent<Zombie>();
        if (zombie == null || zombie.HealthComponent.IsDead)
        {
            return;
        }

        // 触发爆炸
        TriggerExplosion();
    }

    /// <summary>
    /// 触发爆炸
    /// </summary>
    private void TriggerExplosion()
    {
        if (m_HasExploded)
        {
            return;
        }

        Logger.Log("PotatoMine", $"{name} 被触发，切换到攻击状态");

        // 切换到攻击状态，AttackState 会调用攻击策略的 Execute 方法
        // Execute 方法会触发爆炸并设置 m_HasExploded = true
        if (FSMComponent != null)
        {
            FSMComponent.ChangeStatus(FSMType.Attack);
        }
        else
        {
            // 如果没有 FSM 组件，直接执行爆炸（降级方案）
            m_HasExploded = true;
            if (AttackComponent != null && AttackComponent.AttackStrategy is PotatoMineAttackStrategy strategy)
            {
                strategy.TriggerExplosion();
            }
        }
    }

    /// <summary>
    /// 设置已爆炸标志（供攻击策略调用）
    /// </summary>
    public void SetExploded()
    {
        m_HasExploded = true;
        
        // 如果是一次性使用，等待攻击动画播放完成后再销毁植物
        if (m_SkillData != null && m_SkillData.IsOneTimeUse)
        {
            StartCoroutine(DestroyAfterExplosion());
        }
    }

    /// <summary>
    /// 等待攻击动画播放完成
    /// </summary>
    private IEnumerator WaitForAttackAnimation()
    {
        if (Animator == null)
        {
            Logger.LogWarning("PotatoMine", "Animator为空，无法等待攻击动画");
            yield break;
        }

        // 等待几帧，确保动画状态已经切换并开始播放
        yield return null;
        yield return null;
        yield return null;

        // 等待动画真正开始播放（检查normalizedTime是否大于0）
        float waitForStartTime = 0f;
        float maxWaitForStart = 0.5f; // 最多等待0.5秒让动画开始
        bool animationStarted = false;
        
        while (waitForStartTime < maxWaitForStart && Animator != null)
        {
            AnimatorStateInfo stateInfo = Animator.GetCurrentAnimatorStateInfo(0);
            
            // 检查是否在攻击状态，并且动画已经开始播放
            if (FSMComponent != null && FSMComponent.State == FSMType.Attack)
            {
                // 检查动画是否在播放（normalizedTime > 0 或动画长度 > 0）
                if (stateInfo.length > 0 && (stateInfo.normalizedTime > 0 || stateInfo.IsName("Attack")))
                {
                    animationStarted = true;
                    Logger.Log("PotatoMine", $"{name} 攻击动画已开始播放，normalizedTime: {stateInfo.normalizedTime:F2}");
                    break;
                }
            }
            
            waitForStartTime += Time.deltaTime;
            yield return null;
        }

        if (!animationStarted)
        {
            Logger.LogWarning("PotatoMine", $"{name} 攻击动画可能未正确开始播放");
            yield break;
        }

        // 获取当前播放的动画信息
        AnimatorStateInfo currentStateInfo = Animator.GetCurrentAnimatorStateInfo(0);
        
        // 获取动画长度
        float animationLength = currentStateInfo.length;
        
        // 如果动画长度无效，使用默认值
        if (animationLength <= 0)
        {
            animationLength = 1f; // 默认1秒
            Logger.LogWarning("PotatoMine", $"{name} 无法获取攻击动画长度，使用默认值1秒");
        }

        // 保存状态hash用于比较
        int stateHash = currentStateInfo.fullPathHash;
        float startNormalizedTime = currentStateInfo.normalizedTime;
        
        Logger.Log("PotatoMine", $"{name} 开始等待攻击动画播放完成，动画长度: {animationLength}秒，当前normalizedTime: {startNormalizedTime:F2}");

        // 等待动画播放完成
        float maxWaitTime = animationLength * 2f; // 最大等待时间（动画长度的2倍，防止无限等待）
        float elapsedTime = 0f;
        
        while (elapsedTime < maxWaitTime && Animator != null)
        {
            // 检查是否仍在攻击状态
            if (FSMComponent == null || FSMComponent.State != FSMType.Attack)
            {
                Logger.Log("PotatoMine", $"{name} 已离开攻击状态，停止等待动画");
                break;
            }
            
            // 获取当前动画状态
            AnimatorStateInfo currentState = Animator.GetCurrentAnimatorStateInfo(0);
            
            // 检查是否仍在同一个动画状态
            if (currentState.fullPathHash != stateHash)
            {
                // 动画状态已切换，可能动画已经结束或被打断
                Logger.Log("PotatoMine", $"{name} 攻击动画状态已切换，动画可能已结束");
                break;
            }
            
            // 检查动画是否已经播放完成
            // 确保normalizedTime确实从开始值增长到了1（防止一开始就是1的情况）
            if (currentState.normalizedTime >= 1f && currentState.normalizedTime > startNormalizedTime)
            {
                Logger.Log("PotatoMine", $"{name} 攻击动画播放完成，normalizedTime: {currentState.normalizedTime:F2}");
                break;
            }
            
            elapsedTime += Time.deltaTime;
            yield return null;
        }

        Logger.Log("PotatoMine", $"{name} 攻击动画等待完成，总等待时间: {elapsedTime:F2}秒");
    }

    /// <summary>
    /// 爆炸后销毁植物
    /// </summary>
    private IEnumerator DestroyAfterExplosion()
    {
        // 等待攻击动画播放完成
        yield return StartCoroutine(WaitForAttackAnimation());
        
        // 等待一小段时间，确保伤害已应用
        yield return new WaitForSeconds(0.1f);
        
        // 杀死植物
        if (HealthComponent != null && !HealthComponent.IsDead)
        {
            long currentHealth = HealthComponent.CurHealth;
            HealthComponent.TakeDamage(currentHealth);
            Logger.Log("PotatoMine", $"{name} 爆炸后死亡");
            
            // 触发死亡状态
            if (FSMComponent != null && HealthComponent.IsDead)
            {
                FSMComponent.ChangeStatus(FSMType.Dead);
            }
        }
    }

    protected override void OnDestroy()
    {
        // 停止激活协程
        if (m_ArmCoroutine != null)
        {
            StopCoroutine(m_ArmCoroutine);
            m_ArmCoroutine = null;
        }
        
        base.OnDestroy();
    }
}
